#include<iostream>
using namespace std;

#define mod 1000000007  // 模值，题目要求答案对 1e9+7 取模

// dp[l][r][s]：表示子串 s[l..r]（1-based）形成特定类型有效序列的方案数
// 第三维度 s（0~5）对应 6 种状态，分别代表不同类型的有效序列（根据题目规则定义）
long long dp[510][510][6];  
char s[510];  // 输入字符串（1-based 存储，s[1]~s[n]）

// 判断 s[a] 和 s[b] 是否能分别作为左括号和右括号（含通配符 '?'）
bool cmp(int a, int b) {
    return (s[a] == '(' || s[a] == '?') && (s[b] == ')' || s[b] == '?');
}

int main() {
    int n, k;  // n：字符串长度，k：题目中*序列的最大长度限制
    cin >> n >> k;
    scanf("%s", s+1);  // 读入字符串，存储在 s[1]~s[n]（1-based）

    // 初始化：空串（l > r）的状态，用于后续拼接时的基础情况
    // dp[i][i-1][0] = 1 表示长度为 0 的空串，作为*序列的"前缀空状态"（辅助构建*序列）
    for(int i=1; i<=n; i++) dp[i][i-1][0] = 1;

    // 按子串长度从小到大枚举（区间 DP 常规操作）
    for(int len=1; len<=n; len++) {
        // 枚举子串起点 l，终点 r = l + len - 1
        for(int l=1; l<=n - len + 1; l++) {
            int r = l + len - 1;

            // 状态 0：表示由 m 个*组成的非空序列（1 ≤ m ≤ k）
            // 仅当子串长度 ≤k 时可能形成该状态
            if(len <= k) {
                // 转移：在 s[l..r-1] 形成*序列的基础上，s[r] 必须是*或?（可替换为*）
                dp[l][r][0] = dp[l][r-1][0] && (s[r] == '*' || s[r] == '?');
            }

            // 长度 ≥2 的子串才可能形成非*序列的有效结构（如括号对、拼接等）
            if(len >= 2) {
                // 情况1：子串两端为括号对 ( ... )，对应题目规则1、3
                // 先判断 l 和 r 能否作为左、右括号（含?）
                if(cmp(l, r)) {
                    // 状态1：表示"被括号包裹的有效序列"，如 (A)、(SA)、(AS)（A 为有效序列，S 为*序列）
                    // 转移来源：中间子串 [l+1..r-1] 可以是：
                    // - 空串（对应 (S) 中的 S，由状态0表示）
                    // - 状态2/3/4（其他类型的有效序列，用于拼接）
                    dp[l][r][1] = (dp[l+1][r-1][0] + dp[l+1][r-1][2] + dp[l+1][r-1][3] + dp[l+1][r-1][4]) % mod;
                }

                // 情况2：子串拆分为左右两部分拼接（对应题目规则2：AB 或 ASB）
                // 枚举拆分点 i（左部分 [l..i]，右部分 [i+1..r]）
                for(int i=l; i<=r-1; i++) {
                    // 状态2：A + S 型（A 为状态3的序列，S 为状态0的*序列）
                    dp[l][r][2] = (dp[l][r][2] + dp[l][i][3] * dp[i+1][r][0]) % mod;
                    
                    // 状态3：A + B 或 A + S + B 型（A为状态2/3，B为状态1的序列）
                    dp[l][r][3] = (dp[l][r][3] + (dp[l][i][2] + dp[l][i][3]) * dp[i+1][r][1]) % mod;
                    
                    // 状态4：A + B 或 A + S + B 型（A为状态4/5，B为状态1的序列）
                    dp[l][r][4] = (dp[l][r][4] + (dp[l][i][4] + dp[l][i][5]) * dp[i+1][r][1]) % mod;
                    
                    // 状态5：S + B 型（B 为状态4的序列，S 为状态0的*序列）
                    dp[l][r][5] = (dp[l][r][5] + dp[l][i][4] * dp[i+1][r][0]) % mod;
                }
            }

            // 状态5 可额外由状态0（*序列）直接构成（S 本身也是一种基础序列）
            dp[l][r][5] = (dp[l][r][5] + dp[l][r][0]) % mod;
            // 状态3 可额外由状态1（括号包裹序列）直接构成（(...) 本身也是一种基础序列）
            dp[l][r][3] = (dp[l][r][3] + dp[l][r][1]) % mod;
        }
    }

    // 最终答案：整个字符串 s[1..n] 形成状态3的有效序列的方案数
    // 状态3 对应题目中"符合规范的超级括号序列"的最终类型（涵盖所有规则组合）
    cout << dp[1][n][3];

    return 0;
}